Languguage OS 2/Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO/gnu/glibc108.zip/glibc108/manual/libc.cp

Text File | 1993-12-29 | 46KB | 783 lines

\entry {library}{1}{library}
\entry {standards}{1}{standards}
\entry {ANSI C}{2}{ANSI C}
\entry {POSIX}{2}{POSIX}
\entry {POSIX.1}{2}{POSIX.1}
\entry {IEEE Std 1003.1}{2}{IEEE Std 1003.1}
\entry {POSIX.2}{2}{POSIX.2}
\entry {IEEE Std 1003.2}{2}{IEEE Std 1003.2}
\entry {BSD Unix}{3}{BSD Unix}
\entry {4.n BSD Unix}{3}{4.\var {n} BSD Unix}
\entry {Berkeley Unix}{3}{Berkeley Unix}
\entry {SunOS}{3}{SunOS}
\entry {Unix, Berkeley}{3}{Unix, Berkeley}
\entry {SVID}{3}{SVID}
\entry {System V Unix}{3}{System V Unix}
\entry {Unix, System V}{3}{Unix, System V}
\entry {header files}{4}{header files}
\entry {definition (compared to declaration)}{4}{definition (compared to declaration)}
\entry {declaration (compared to definition)}{4}{declaration (compared to definition)}
\entry {shadowing functions with macros}{5}{shadowing functions with macros}
\entry {removing macros that shadow functions}{5}{removing macros that shadow functions}
\entry {undefining macros that shadow functions}{5}{undefining macros that shadow functions}
\entry {reserved names}{6}{reserved names}
\entry {name space}{6}{name space}
\entry {feature test macros}{8}{feature test macros}
\entry {BSD compatibility library.}{9}{BSD compatibility library.}
\entry {error reporting}{13}{error reporting}
\entry {reporting errors}{13}{reporting errors}
\entry {error codes}{13}{error codes}
\entry {status codes}{13}{status codes}
\entry {program name}{23}{program name}
\entry {name of running program}{23}{name of running program}
\entry {memory allocation}{25}{memory allocation}
\entry {storage allocation}{25}{storage allocation}
\entry {dynamic allocation}{25}{dynamic allocation}
\entry {static allocation}{25}{static allocation}
\entry {automatic allocation}{25}{automatic allocation}
\entry {unconstrained storage allocation}{26}{unconstrained storage allocation}
\entry {malloc function}{26}{\code {malloc} function}
\entry {heap, dynamic allocation from}{26}{heap, dynamic allocation from}
\entry {allocation of memory with malloc}{26}{allocation of memory with \code {malloc}}
\entry {freeing memory allocated with malloc}{28}{freeing memory allocated with \code {malloc}}
\entry {heap, freeing memory from}{28}{heap, freeing memory from}
\entry {changing the size of a block (malloc)}{29}{changing the size of a block (\code {malloc})}
\entry {efficiency and malloc}{31}{efficiency and \code {malloc}}
\entry {page boundary}{31}{page boundary}
\entry {alignment (with malloc)}{31}{alignment (with \code {malloc})}
\entry {heap consistency checking}{32}{heap consistency checking}
\entry {consistency checking, of heap}{32}{consistency checking, of heap}
\entry {allocation hooks, for malloc}{32}{allocation hooks, for \code {malloc}}
\entry {allocation statistics}{33}{allocation statistics}
\entry {obstacks}{35}{obstacks}
\entry {allocation (obstacks)}{37}{allocation (obstacks)}
\entry {freeing (obstacks)}{38}{freeing (obstacks)}
\entry {macros}{38}{macros}
\entry {growing objects (in obstacks)}{39}{growing objects (in obstacks)}
\entry {changing the size of a block (obstacks)}{39}{changing the size of a block (obstacks)}
\entry {shrinking objects}{41}{shrinking objects}
\entry {efficiency and obstacks}{41}{efficiency and obstacks}
\entry {obstack status}{42}{obstack status}
\entry {status of obstack}{42}{status of obstack}
\entry {alignment (in obstacks)}{43}{alignment (in obstacks)}
\entry {efficiency of chunks}{44}{efficiency of chunks}
\entry {chunks}{44}{chunks}
\entry {automatic freeing}{46}{automatic freeing}
\entry {alloca function}{46}{\code {alloca} function}
\entry {automatic storage with variable size}{46}{automatic storage with variable size}
\entry {longjmp}{48}{longjmp}
\entry {alloca disadvantages}{48}{\code {alloca} disadvantages}
\entry {disadvantages of alloca}{48}{disadvantages of \code {alloca}}
\entry {variable-sized arrays}{49}{variable-sized arrays}
\entry {relocating memory allocator}{49}{relocating memory allocator}
\entry {handle}{49}{handle}
\entry {memory usage warnings}{50}{memory usage warnings}
\entry {warnings of memory almost full}{50}{warnings of memory almost full}
\entry {character testing}{53}{character testing}
\entry {classification of characters}{53}{classification of characters}
\entry {predicates on characters}{53}{predicates on characters}
\entry {character predicates}{53}{character predicates}
\entry {lower-case character}{53}{lower-case character}
\entry {upper-case character}{53}{upper-case character}
\entry {alphabetic character}{53}{alphabetic character}
\entry {digit character}{53}{digit character}
\entry {decimal digit character}{53}{decimal digit character}
\entry {alphanumeric character}{54}{alphanumeric character}
\entry {hexadecimal digit character}{54}{hexadecimal digit character}
\entry {punctuation character}{54}{punctuation character}
\entry {whitespace character}{54}{whitespace character}
\entry {blank character}{54}{blank character}
\entry {graphic character}{54}{graphic character}
\entry {printing character}{54}{printing character}
\entry {control character}{55}{control character}
\entry {ASCII character}{55}{ASCII character}
\entry {character case conversion}{55}{character case conversion}
\entry {case conversion of characters}{55}{case conversion of characters}
\entry {converting case of characters}{55}{converting case of characters}
\entry {string, representation of}{57}{string, representation of}
\entry {string}{57}{string}
\entry {null character}{57}{null character}
\entry {string literal}{57}{string literal}
\entry {length of string}{58}{length of string}
\entry {allocation size of string}{58}{allocation size of string}
\entry {size of string}{58}{size of string}
\entry {string length}{58}{string length}
\entry {string allocation}{58}{string allocation}
\entry {copying strings and arrays}{59}{copying strings and arrays}
\entry {string copy functions}{59}{string copy functions}
\entry {array copy functions}{59}{array copy functions}
\entry {concatenating strings}{59}{concatenating strings}
\entry {string concatenation functions}{59}{string concatenation functions}
\entry {comparing strings and arrays}{63}{comparing strings and arrays}
\entry {string comparison functions}{63}{string comparison functions}
\entry {array comparison functions}{63}{array comparison functions}
\entry {predicates on strings}{63}{predicates on strings}
\entry {predicates on arrays}{63}{predicates on arrays}
\entry {collating strings}{65}{collating strings}
\entry {string collation functions}{65}{string collation functions}
\entry {converting string to collation order}{66}{converting string to collation order}
\entry {search functions (for strings)}{68}{search functions (for strings)}
\entry {string search functions}{68}{string search functions}
\entry {tokenizing strings}{70}{tokenizing strings}
\entry {breaking a string into tokens}{70}{breaking a string into tokens}
\entry {parsing tokens from a string}{70}{parsing tokens from a string}
\entry {opening a file}{73}{opening a file}
\entry {file position}{75}{file position}
\entry {sequential-access files}{75}{sequential-access files}
\entry {random-access files}{75}{random-access files}
\entry {append-access files}{75}{append-access files}
\entry {file name}{75}{file name}
\entry {directory}{76}{directory}
\entry {link}{76}{link}
\entry {directory entry}{76}{directory entry}
\entry {file name component}{76}{file name component}
\entry {file name resolution}{76}{file name resolution}
\entry {root directory}{76}{root directory}
\entry {absolute file name}{76}{absolute file name}
\entry {relative file name}{76}{relative file name}
\entry {parent directory}{77}{parent directory}
\entry {file name syntax errors}{77}{file name syntax errors}
\entry {usual file name syntax errors}{77}{usual file name syntax errors}
\entry {file pointer}{81}{file pointer}
\entry {standard streams}{81}{standard streams}
\entry {streams, standard}{81}{streams, standard}
\entry {standard input stream}{81}{standard input stream}
\entry {standard output stream}{82}{standard output stream}
\entry {standard error stream}{82}{standard error stream}
\entry {opening a stream}{82}{opening a stream}
\entry {closing a stream}{84}{closing a stream}
\entry {writing to a stream, by characters}{85}{writing to a stream, by characters}
\entry {reading from a stream, by characters}{86}{reading from a stream, by characters}
\entry {peeking at input}{89}{peeking at input}
\entry {unreading characters}{89}{unreading characters}
\entry {pushing input back}{89}{pushing input back}
\entry {format string, for printf}{91}{format string, for \code {printf}}
\entry {template, for printf}{91}{template, for \code {printf}}
\entry {formatted output to a stream}{91}{formatted output to a stream}
\entry {writing to a stream, formatted}{91}{writing to a stream, formatted}
\entry {conversion specifications (printf)}{92}{conversion specifications (\code {printf})}
\entry {flag character (printf)}{93}{flag character (\code {printf})}
\entry {minimum field width (printf)}{93}{minimum field width (\code {printf})}
\entry {precision (printf)}{93}{precision (\code {printf})}
\entry {type modifier character (printf)}{94}{type modifier character (\code {printf})}
\entry {output conversions, for printf}{94}{output conversions, for \code {printf}}
\entry {parsing a template string}{104}{parsing a template string}
\entry {customizing printf}{107}{customizing \code {printf}}
\entry {defining new printf conversions}{107}{defining new \code {printf} conversions}
\entry {extending printf}{107}{extending \code {printf}}
\entry {formatted input from a stream}{112}{formatted input from a stream}
\entry {reading from a stream, formatted}{112}{reading from a stream, formatted}
\entry {format string, for scanf}{112}{format string, for \code {scanf}}
\entry {template, for scanf}{112}{template, for \code {scanf}}
\entry {conversion specifications (scanf)}{113}{conversion specifications (\code {scanf})}
\entry {matching failure, in scanf}{113}{matching failure, in \code {scanf}}
\entry {flag character (scanf)}{114}{flag character (\code {scanf})}
\entry {maximum field width (scanf)}{114}{maximum field width (\code {scanf})}
\entry {type modifier character (scanf)}{114}{type modifier character (\code {scanf})}
\entry {input conversions, for scanf}{114}{input conversions, for \code {scanf}}
\entry {binary I/O to a stream}{121}{binary I/O to a stream}
\entry {block I/O to a stream}{121}{block I/O to a stream}
\entry {reading from a stream, by blocks}{121}{reading from a stream, by blocks}
\entry {writing to a stream, by blocks}{121}{writing to a stream, by blocks}
\entry {end of file, on a stream}{121}{end of file, on a stream}
\entry {text stream}{122}{text stream}
\entry {binary stream}{122}{binary stream}
\entry {lines (in a text file)}{123}{lines (in a text file)}
\entry {file positioning on a stream}{123}{file positioning on a stream}
\entry {positioning a stream}{123}{positioning a stream}
\entry {seeking on a stream}{123}{seeking on a stream}
\entry {buffering of streams}{126}{buffering of streams}
\entry {unbuffered stream}{127}{unbuffered stream}
\entry {line buffered stream}{127}{line buffered stream}
\entry {fully buffered stream}{127}{fully buffered stream}
\entry {flushing a stream}{128}{flushing a stream}
\entry {buffering, controlling}{128}{buffering, controlling}
\entry {stream, for I/O to a string}{131}{stream, for I/O to a string}
\entry {string stream}{131}{string stream}
\entry {custom streams}{134}{custom streams}
\entry {programming your own streams}{134}{programming your own streams}
\entry {cookie, for custom stream}{134}{cookie, for custom stream}
\entry {hook functions (of custom streams)}{135}{hook functions (of custom streams)}
\entry {opening a file descriptor}{137}{opening a file descriptor}
\entry {closing a file descriptor}{137}{closing a file descriptor}
\entry {append mode (file status flag)}{138}{append mode (file status flag)}
\entry {create on open (file status flag)}{138}{create on open (file status flag)}
\entry {non-blocking mode (file status flag)}{138}{non-blocking mode (file status flag)}
\entry {reading from a file descriptor}{140}{reading from a file descriptor}
\entry {end-of-file, on a file descriptor}{140}{end-of-file, on a file descriptor}
\entry {writing to a file descriptor}{141}{writing to a file descriptor}
\entry {file positioning on a file descriptor}{143}{file positioning on a file descriptor}
\entry {positioning a file descriptor}{143}{positioning a file descriptor}
\entry {seeking on a file descriptor}{143}{seeking on a file descriptor}
\entry {streams, and file descriptors}{145}{streams, and file descriptors}
\entry {converting file descriptor to stream}{145}{converting file descriptor to stream}
\entry {extracting file descriptor from stream}{145}{extracting file descriptor from stream}
\entry {standard file descriptors}{146}{standard file descriptors}
\entry {file descriptors, standard}{146}{file descriptors, standard}
\entry {standard input file descriptor}{146}{standard input file descriptor}
\entry {standard output file descriptor}{146}{standard output file descriptor}
\entry {standard error file descriptor}{146}{standard error file descriptor}
\entry {channels}{146}{channels}
\entry {streams and descriptors}{146}{streams and descriptors}
\entry {descriptors and streams}{146}{descriptors and streams}
\entry {mixing descriptors and streams}{146}{mixing descriptors and streams}
\entry {linked channels}{147}{linked channels}
\entry {cleaning up a stream}{147}{cleaning up a stream}
\entry {independent channels}{147}{independent channels}
\entry {waiting for input or output}{148}{waiting for input or output}
\entry {multiplexing input}{148}{multiplexing input}
\entry {input from multiple files}{148}{input from multiple files}
\entry {file descriptor sets, for select}{149}{file descriptor sets, for \code {select}}
\entry {control operations on files}{152}{control operations on files}
\entry {fcntl function}{152}{\code {fcntl} function}
\entry {duplicating file descriptors}{153}{duplicating file descriptors}
\entry {redirecting input and output}{153}{redirecting input and output}
\entry {file descriptor flags}{155}{file descriptor flags}
\entry {close-on-exec (file descriptor flag)}{155}{close-on-exec (file descriptor flag)}
\entry {file status flags}{156}{file status flags}
\entry {file locks}{158}{file locks}
\entry {record locking}{158}{record locking}
\entry {exclusive lock}{158}{exclusive lock}
\entry {write lock}{158}{write lock}
\entry {shared lock}{158}{shared lock}
\entry {read lock}{158}{read lock}
\entry {interrupt-driven input}{162}{interrupt-driven input}
\entry {current working directory}{165}{current working directory}
\entry {working directory}{165}{working directory}
\entry {change working directory}{165}{change working directory}
\entry {accessing directories}{167}{accessing directories}
\entry {reading from a directory}{167}{reading from a directory}
\entry {directories, accessing}{167}{directories, accessing}
\entry {directory stream}{167}{directory stream}
\entry {hard link}{170}{hard link}
\entry {link, hard}{170}{link, hard}
\entry {multiple names for one file}{170}{multiple names for one file}
\entry {file names, multiple}{170}{file names, multiple}
\entry {soft link}{171}{soft link}
\entry {link, soft}{171}{link, soft}
\entry {symbolic link}{171}{symbolic link}
\entry {link, symbolic}{171}{link, symbolic}
\entry {deleting a file}{173}{deleting a file}
\entry {removing a file}{173}{removing a file}
\entry {unlinking a file}{173}{unlinking a file}
\entry {directories, deleting}{174}{directories, deleting}
\entry {deleting a directory}{174}{deleting a directory}
\entry {renaming a file}{174}{renaming a file}
\entry {creating a directory}{176}{creating a directory}
\entry {directories, creating}{176}{directories, creating}
\entry {status of a file}{177}{status of a file}
\entry {attributes of a file}{177}{attributes of a file}
\entry {file attributes}{177}{file attributes}
\entry {inode number}{179}{inode number}
\entry {file owner}{182}{file owner}
\entry {owner of a file}{182}{owner of a file}
\entry {group owner of a file}{182}{group owner of a file}
\entry {file permission bits}{184}{file permission bits}
\entry {sticky bit}{185}{sticky bit}
\entry {permission to access a file}{185}{permission to access a file}
\entry {access permission for a file}{185}{access permission for a file}
\entry {file access permission}{185}{file access permission}
\entry {file creation mask}{186}{file creation mask}
\entry {umask}{186}{umask}
\entry {testing access permission}{188}{testing access permission}
\entry {access, testing for}{188}{access, testing for}
\entry {setuid programs and file access}{188}{setuid programs and file access}
\entry {file access time}{189}{file access time}
\entry {file modification time}{189}{file modification time}
\entry {file attribute modification time}{189}{file attribute modification time}
\entry {creating special files}{191}{creating special files}
\entry {special files}{191}{special files}
\entry {TMPDIR environment variable}{193}{TMPDIR environment variable}
\entry {pipe}{195}{pipe}
\entry {FIFO special file}{195}{FIFO special file}
\entry {creating a pipe}{195}{creating a pipe}
\entry {opening a pipe}{195}{opening a pipe}
\entry {interprocess communication, with pipes}{195}{interprocess communication, with pipes}
\entry {creating a pipe to a subprocess}{197}{creating a pipe to a subprocess}
\entry {pipe to a subprocess}{197}{pipe to a subprocess}
\entry {filtering i/o through subprocess}{197}{filtering i/o through subprocess}
\entry {creating a FIFO special file}{199}{creating a FIFO special file}
\entry {interprocess communication, with FIFO}{199}{interprocess communication, with FIFO}
\entry {socket}{201}{socket}
\entry {interprocess communication, with sockets}{201}{interprocess communication, with sockets}
\entry {communication style (of a socket)}{201}{communication style (of a socket)}
\entry {style of communication (of a socket)}{201}{style of communication (of a socket)}
\entry {packet}{201}{packet}
\entry {byte stream}{201}{byte stream}
\entry {stream (sockets)}{201}{stream (sockets)}
\entry {loss of data on sockets}{201}{loss of data on sockets}
\entry {data loss on sockets}{201}{data loss on sockets}
\entry {namespace (of socket)}{201}{namespace (of socket)}
\entry {domain (of socket)}{201}{domain (of socket)}
\entry {socket namespace}{201}{socket namespace}
\entry {socket domain}{201}{socket domain}
\entry {network protocol}{202}{network protocol}
\entry {protocol (of socket)}{202}{protocol (of socket)}
\entry {socket protocol}{202}{socket protocol}
\entry {protocol family}{202}{protocol family}
\entry {address of socket}{203}{address of socket}
\entry {name of socket}{203}{name of socket}
\entry {binding a socket address}{203}{binding a socket address}
\entry {socket address (name) binding}{203}{socket address (name) binding}
\entry {file namespace, for sockets}{206}{file namespace, for sockets}
\entry {Internet namespace, for sockets}{209}{Internet namespace, for sockets}
\entry {host address, Internet}{210}{host address, Internet}
\entry {Internet host address}{210}{Internet host address}
\entry {network number}{210}{network number}
\entry {local network address number}{210}{local network address number}
\entry {standard dot notation, for Internet addresses}{211}{standard dot notation, for Internet addresses}
\entry {dot notation, for Internet addresses}{211}{dot notation, for Internet addresses}
\entry {hosts database}{213}{hosts database}
\entry {converting host name to address}{213}{converting host name to address}
\entry {converting host address to name}{213}{converting host address to name}
\entry {port number}{216}{port number}
\entry {services database}{217}{services database}
\entry {converting service name to port number}{217}{converting service name to port number}
\entry {converting port number to service name}{217}{converting port number to service name}
\entry {byte order conversion, for socket}{218}{byte order conversion, for socket}
\entry {converting byte order}{218}{converting byte order}
\entry {big-endian}{218}{big-endian}
\entry {little-endian}{218}{little-endian}
\entry {network byte order}{218}{network byte order}
\entry {protocols database}{219}{protocols database}
\entry {TCP (Internet protocol)}{219}{TCP (Internet protocol)}
\entry {creating a socket}{222}{creating a socket}
\entry {socket, creating}{222}{socket, creating}
\entry {opening a socket}{222}{opening a socket}
\entry {socket, closing}{223}{socket, closing}
\entry {closing a socket}{223}{closing a socket}
\entry {shutting down a socket}{223}{shutting down a socket}
\entry {socket shutdown}{223}{socket shutdown}
\entry {creating a socket pair}{224}{creating a socket pair}
\entry {socket pair}{224}{socket pair}
\entry {opening a socket pair}{224}{opening a socket pair}
\entry {connection}{225}{connection}
\entry {client}{225}{client}
\entry {server}{225}{server}
\entry {connecting a socket}{225}{connecting a socket}
\entry {socket, connecting}{225}{socket, connecting}
\entry {socket, initiating a connection}{225}{socket, initiating a connection}
\entry {socket, client actions}{225}{socket, client actions}
\entry {listening (sockets)}{226}{listening (sockets)}
\entry {sockets, server actions}{226}{sockets, server actions}
\entry {sockets, listening}{226}{sockets, listening}
\entry {sockets, accepting connections}{227}{sockets, accepting connections}
\entry {accepting connections}{227}{accepting connections}
\entry {reading from a socket}{229}{reading from a socket}
\entry {writing to a socket}{229}{writing to a socket}
\entry {out-of-band data}{235}{out-of-band data}
\entry {high-priority data}{235}{high-priority data}
\entry {urgent socket condition}{235}{urgent socket condition}
\entry {datagram socket}{238}{datagram socket}
\entry {sending a datagram}{239}{sending a datagram}
\entry {transmitting datagrams}{239}{transmitting datagrams}
\entry {datagrams, transmitting}{239}{datagrams, transmitting}
\entry {receiving datagrams}{239}{receiving datagrams}
\entry {socket options}{244}{socket options}
\entry {level, for socket options}{244}{level, for socket options}
\entry {socket option level}{244}{socket option level}
\entry {networks database}{247}{networks database}
\entry {converting network number to network name}{247}{converting network number to network name}
\entry {converting network name to network number}{247}{converting network name to network number}
\entry {terminal identification}{249}{terminal identification}
\entry {identifying terminals}{249}{identifying terminals}
\entry {terminal input queue}{249}{terminal input queue}
\entry {typeahead buffer}{249}{typeahead buffer}
\entry {terminal output queue}{250}{terminal output queue}
\entry {canonical input processing}{250}{canonical input processing}
\entry {noncanonical input processing}{250}{noncanonical input processing}
\entry {terminal mode data types}{251}{terminal mode data types}
\entry {terminal mode functions}{252}{terminal mode functions}
\entry {parity checking}{255}{parity checking}
\entry {break condition, detecting}{255}{break condition, detecting}
\entry {modem status lines}{257}{modem status lines}
\entry {carrier detect}{257}{carrier detect}
\entry {modem disconnect}{258}{modem disconnect}
\entry {echo of terminal input}{259}{echo of terminal input}
\entry {interactive signals, from terminal}{260}{interactive signals, from terminal}
\entry {line speed}{261}{line speed}
\entry {baud rate}{261}{baud rate}
\entry {terminal line speed}{261}{terminal line speed}
\entry {terminal line speed}{261}{terminal line speed}
\entry {EOF character}{263}{EOF character}
\entry {EOL character}{264}{EOL character}
\entry {ERASE character}{264}{ERASE character}
\entry {KILL character}{264}{KILL character}
\entry {EOL2 character}{264}{EOL2 character}
\entry {WERASE character}{265}{WERASE character}
\entry {REPRINT character}{265}{REPRINT character}
\entry {LNEXT character}{265}{LNEXT character}
\entry {INTR character}{265}{INTR character}
\entry {interrupt character}{265}{interrupt character}
\entry {QUIT character}{266}{QUIT character}
\entry {SUSP character}{266}{SUSP character}
\entry {suspend character}{266}{suspend character}
\entry {DSUSP character}{266}{DSUSP character}
\entry {delayed suspend character}{266}{delayed suspend character}
\entry {START character}{267}{START character}
\entry {STOP character}{267}{STOP character}
\entry {DISCARD character}{267}{DISCARD character}
\entry {STATUS character}{268}{STATUS character}
\entry {MIN termios slot}{268}{MIN termios slot}
\entry {TIME termios slot}{268}{TIME termios slot}
\entry {terminal line control functions}{269}{terminal line control functions}
\entry {break condition, generating}{270}{break condition, generating}
\entry {flushing terminal output queue}{270}{flushing terminal output queue}
\entry {terminal output queue, flushing}{270}{terminal output queue, flushing}
\entry {clearing terminal input queue}{270}{clearing terminal input queue}
\entry {terminal input queue, clearing}{270}{terminal input queue, clearing}
\entry {flow control, terminal}{271}{flow control, terminal}
\entry {terminal flow control}{271}{terminal flow control}
\entry {domain error}{275}{domain error}
\entry {range error}{275}{range error}
\entry {trigonometric functions}{276}{trigonometric functions}
\entry {pi (trigonometric constant)}{276}{pi (trigonometric constant)}
\entry {inverse trigonmetric functions}{277}{inverse trigonmetric functions}
\entry {exponentiation functions}{278}{exponentiation functions}
\entry {power functions}{278}{power functions}
\entry {logarithm functions}{278}{logarithm functions}
\entry {square root function}{278}{square root function}
\entry {cube root function}{278}{cube root function}
\entry {hyperbolic functions}{279}{hyperbolic functions}
\entry {inverse hyperbolic functions}{279}{inverse hyperbolic functions}
\entry {random numbers}{280}{random numbers}
\entry {pseudo-random numbers}{280}{pseudo-random numbers}
\entry {seed (for random numbers)}{280}{seed (for random numbers)}
\entry {NaN}{283}{NaN}
\entry {not a number}{283}{not a number}
\entry {IEEE floating point}{283}{IEEE floating point}
\entry {absolute value functions}{284}{absolute value functions}
\entry {normalization functions (floating-point)}{285}{normalization functions (floating-point)}
\entry {rounding functions}{286}{rounding functions}
\entry {remainder functions}{286}{remainder functions}
\entry {converting floats to integers}{286}{converting floats to integers}
\entry {integer division functions}{287}{integer division functions}
\entry {parsing numbers (in formatted input)}{288}{parsing numbers (in formatted input)}
\entry {converting strings to numbers}{288}{converting strings to numbers}
\entry {number syntax, parsing}{288}{number syntax, parsing}
\entry {syntax, for reading numbers}{288}{syntax, for reading numbers}
\entry {Comparison Function}{293}{Comparison Function}
\entry {search function (for arrays)}{293}{search function (for arrays)}
\entry {binary search function (for arrays)}{293}{binary search function (for arrays)}
\entry {array search function}{293}{array search function}
\entry {sort function (for arrays)}{294}{sort function (for arrays)}
\entry {quick sort function (for arrays)}{294}{quick sort function (for arrays)}
\entry {array sort function}{294}{array sort function}
\entry {stable sorting}{294}{stable sorting}
\entry {Kermit the frog}{296}{Kermit the frog}
\entry {globbing}{300}{globbing}
\entry {word expansion}{310}{word expansion}
\entry {expansion of shell words}{310}{expansion of shell words}
\entry {tilde expansion}{310}{tilde expansion}
\entry {variable substitution}{310}{variable substitution}
\entry {substitution of variables and commands}{310}{substitution of variables and commands}
\entry {command substitution}{310}{command substitution}
\entry {arithmetic expansion}{310}{arithmetic expansion}
\entry {field splitting}{310}{field splitting}
\entry {wildcard expansion}{310}{wildcard expansion}
\entry {quote removal}{310}{quote removal}
\entry {removal of quotes}{310}{removal of quotes}
\entry {CPU time}{315}{CPU time}
\entry {processor time}{315}{processor time}
\entry {clock ticks}{315}{clock ticks}
\entry {ticks, clock}{315}{ticks, clock}
\entry {time, elapsed CPU}{315}{time, elapsed CPU}
\entry {Gregorian calendar}{317}{Gregorian calendar}
\entry {time, calendar}{317}{time, calendar}
\entry {date and time}{317}{date and time}
\entry {calendar time}{317}{calendar time}
\entry {high-resolution time}{317}{high-resolution time}
\entry {local time}{317}{local time}
\entry {broken-down time}{317}{broken-down time}
\entry {epoch}{318}{epoch}
\entry {broken-down time}{321}{broken-down time}
\entry {calendar time and broken-down time}{321}{calendar time and broken-down time}
\entry {leap second}{321}{leap second}
\entry {Daylight Saving Time}{322}{Daylight Saving Time}
\entry {summer time}{322}{summer time}
\entry {time zone}{326}{time zone}
\entry {setting an alarm}{329}{setting an alarm}
\entry {interval timer, setting}{329}{interval timer, setting}
\entry {alarms, setting}{329}{alarms, setting}
\entry {timers, setting}{329}{timers, setting}
\entry {real-time timer}{329}{real-time timer}
\entry {virtual timer}{329}{virtual timer}
\entry {profiling timer}{329}{profiling timer}
\entry {resource limits}{334}{resource limits}
\entry {limits on resource usage}{334}{limits on resource usage}
\entry {usage limits}{334}{usage limits}
\entry {process priority}{335}{process priority}
\entry {priority of a process}{335}{priority of a process}
\entry {extended character sets}{339}{extended character sets}
\entry {wide characters}{339}{wide characters}
\entry {multibyte characters}{340}{multibyte characters}
\entry {basic byte sequence}{340}{basic byte sequence}
\entry {code, character}{343}{code, character}
\entry {character code}{343}{character code}
\entry {extended strings, converting representations}{344}{extended strings, converting representations}
\entry {converting extended strings}{344}{converting extended strings}
\entry {multibyte character, length of}{345}{multibyte character, length of}
\entry {length of multibyte character}{345}{length of multibyte character}
\entry {extended characters, converting}{346}{extended characters, converting}
\entry {converting extended characters}{346}{converting extended characters}
\entry {internationalization}{351}{internationalization}
\entry {locales}{351}{locales}
\entry {combining locales}{352}{combining locales}
\entry {categories for locales}{352}{categories for locales}
\entry {locale categories}{352}{locale categories}
\entry {changing the locale}{353}{changing the locale}
\entry {locale, changing}{353}{locale, changing}
\entry {monetary value formatting}{355}{monetary value formatting}
\entry {numeric value formatting}{355}{numeric value formatting}
\entry {decimal-point separator}{356}{decimal-point separator}
\entry {grouping of digits}{356}{grouping of digits}
\entry {currency symbols}{357}{currency symbols}
\entry {non-local exits}{361}{non-local exits}
\entry {long jumps}{361}{long jumps}
\entry {signal}{365}{signal}
\entry {generation of signals}{366}{generation of signals}
\entry {delivery of signals}{366}{delivery of signals}
\entry {pending signals}{366}{pending signals}
\entry {blocked signals}{366}{blocked signals}
\entry {specified action (for a signal)}{366}{specified action (for a signal)}
\entry {default action (for a signal)}{366}{default action (for a signal)}
\entry {signal action}{366}{signal action}
\entry {catching signals}{366}{catching signals}
\entry {signal names}{367}{signal names}
\entry {names of signals}{367}{names of signals}
\entry {signal number}{367}{signal number}
\entry {program error signals}{368}{program error signals}
\entry {exception}{369}{exception}
\entry {floating-point exception}{369}{floating-point exception}
\entry {illegal instruction}{370}{illegal instruction}
\entry {segmentation violation}{370}{segmentation violation}
\entry {bus error}{370}{bus error}
\entry {abort signal}{370}{abort signal}
\entry {program termination signals}{371}{program termination signals}
\entry {hangup signal}{371}{hangup signal}
\entry {interrupt signal}{371}{interrupt signal}
\entry {quit signal}{371}{quit signal}
\entry {quit signal}{371}{quit signal}
\entry {termination signal}{372}{termination signal}
\entry {kill signal}{372}{kill signal}
\entry {alarm signal}{372}{alarm signal}
\entry {virtual time alarm signal}{372}{virtual time alarm signal}
\entry {profiling alarm signal}{373}{profiling alarm signal}
\entry {input available signal}{373}{input available signal}
\entry {output possible signal}{373}{output possible signal}
\entry {urgent data signal}{373}{urgent data signal}
\entry {job control signals}{373}{job control signals}
\entry {child process signal}{373}{child process signal}
\entry {continue signal}{373}{continue signal}
\entry {stop signal}{374}{stop signal}
\entry {interactive stop signal}{374}{interactive stop signal}
\entry {terminal input signal}{374}{terminal input signal}
\entry {terminal output signal}{374}{terminal output signal}
\entry {pipe signal}{375}{pipe signal}
\entry {broken pipe signal}{375}{broken pipe signal}
\entry {user signals}{375}{user signals}
\entry {signal messages}{376}{signal messages}
\entry {signal actions}{377}{signal actions}
\entry {establishing a handler}{377}{establishing a handler}
\entry {signal function}{377}{\code {signal} function}
\entry {default action for a signal}{378}{default action for a signal}
\entry {ignore action for a signal}{378}{ignore action for a signal}
\entry {sigaction function}{380}{\code {sigaction} function}
\entry {signal flags}{383}{signal flags}
\entry {flags for sigaction}{383}{flags for \code {sigaction}}
\entry {sigaction flags}{383}{\code {sigaction} flags}
\entry {initial signal actions}{384}{initial signal actions}
\entry {signal handler function}{385}{signal handler function}
\entry {non-local exit, from signal handler}{387}{non-local exit, from signal handler}
\entry {race conditions, relating to signals}{388}{race conditions, relating to signals}
\entry {handling multiple signals}{389}{handling multiple signals}
\entry {successive signals}{389}{successive signals}
\entry {merging of signals}{389}{merging of signals}
\entry {restrictions on signal handler functions}{392}{restrictions on signal handler functions}
\entry {volatile declarations}{392}{\code {volatile} declarations}
\entry {reentrant functions}{392}{reentrant functions}
\entry {sending signals}{398}{sending signals}
\entry {raising signals}{398}{raising signals}
\entry {signals, generating}{398}{signals, generating}
\entry {killing a process}{399}{killing a process}
\entry {interprocess communication, with signals}{401}{interprocess communication, with signals}
\entry {blocking signals}{402}{blocking signals}
\entry {signal set}{403}{signal set}
\entry {signal mask}{405}{signal mask}
\entry {process signal mask}{405}{process signal mask}
\entry {blocking signals, in a handler}{407}{blocking signals, in a handler}
\entry {pending signals, checking for}{408}{pending signals, checking for}
\entry {blocked signals, checking for}{408}{blocked signals, checking for}
\entry {checking for pending signals}{408}{checking for pending signals}
\entry {timing error in signal handling}{410}{timing error in signal handling}
\entry {waiting for a signal}{411}{waiting for a signal}
\entry {pause function}{411}{\code {pause} function}
\entry {signal stack}{414}{signal stack}
\entry {process}{419}{process}
\entry {program arguments}{419}{program arguments}
\entry {command line arguments}{419}{command line arguments}
\entry {main function}{419}{\code {main} function}
\entry {argc (program argument count)}{419}{argc (program argument count)}
\entry {argv (program argument vector)}{419}{argv (program argument vector)}
\entry {program argument syntax}{420}{program argument syntax}
\entry {syntax, for program arguments}{420}{syntax, for program arguments}
\entry {command argument syntax}{420}{command argument syntax}
\entry {long-named options}{420}{long-named options}
\entry {program arguments, parsing}{421}{program arguments, parsing}
\entry {command arguments, parsing}{421}{command arguments, parsing}
\entry {parsing program arguments}{421}{parsing program arguments}
\entry {environment variable}{428}{environment variable}
\entry {environment}{428}{environment}
\entry {environment access}{428}{environment access}
\entry {environment representation}{428}{environment representation}
\entry {standard environment variables}{429}{standard environment variables}
\entry {HOME environment variable}{429}{HOME environment variable}
\entry {home directory}{429}{home directory}
\entry {LOGNAME environment variable}{429}{LOGNAME environment variable}
\entry {PATH environment variable}{430}{PATH environment variable}
\entry {TERM environment variable}{430}{TERM environment variable}
\entry {TZ environment variable}{430}{TZ environment variable}
\entry {LANG environment variable}{430}{LANG environment variable}
\entry {LC{\_}COLLATE environment variable}{431}{LC{\_}COLLATE environment variable}
\entry {LC{\_}CTYPE environment variable}{431}{LC{\_}CTYPE environment variable}
\entry {LC{\_}MONETARY environment variable}{431}{LC{\_}MONETARY environment variable}
\entry {LC{\_}NUMERIC environment variable}{431}{LC{\_}NUMERIC environment variable}
\entry {LC{\_}TIME environment variable}{431}{LC{\_}TIME environment variable}
\entry {{\_}POSIX{\_}OPTION{\_}ORDER environment variable.}{431}{{\_}POSIX{\_}OPTION{\_}ORDER environment variable.}
\entry {program termination}{431}{program termination}
\entry {process termination}{431}{process termination}
\entry {exit status value}{431}{exit status value}
\entry {exit status}{432}{exit status}
\entry {aborting a program}{434}{aborting a program}
\entry {process}{437}{process}
\entry {child process}{437}{child process}
\entry {parent process}{437}{parent process}
\entry {running a command}{437}{running a command}
\entry {process ID}{438}{process ID}
\entry {process lifetime}{438}{process lifetime}
\entry {creating a process}{438}{creating a process}
\entry {forking a process}{438}{forking a process}
\entry {child process}{438}{child process}
\entry {parent process}{438}{parent process}
\entry {process image}{438}{process image}
\entry {executing a file}{440}{executing a file}
\entry {exec functions}{440}{\code {exec} functions}
\entry {process completion}{443}{process completion}
\entry {waiting for completion of child process}{443}{waiting for completion of child process}
\entry {testing exit status of child process}{443}{testing exit status of child process}
\entry {process groups}{449}{process groups}
\entry {job control}{449}{job control}
\entry {job}{449}{job}
\entry {session}{449}{session}
\entry {shell}{449}{shell}
\entry {session}{449}{session}
\entry {session leader}{449}{session leader}
\entry {controlling terminal}{450}{controlling terminal}
\entry {foreground job}{450}{foreground job}
\entry {background job}{450}{background job}
\entry {stopped job}{450}{stopped job}
\entry {job control is optional}{450}{job control is optional}
\entry {controlling process}{451}{controlling process}
\entry {controlling terminal, access to}{451}{controlling terminal, access to}
\entry {SIGTTIN, from background job}{451}{\code {SIGTTIN}, from background job}
\entry {SIGTTOU, from background job}{451}{\code {SIGTTOU}, from background job}
\entry {orphaned process group}{451}{orphaned process group}
\entry {job control, enabling}{454}{job control, enabling}
\entry {subshell}{454}{subshell}
\entry {job control, enabling}{454}{job control, enabling}
\entry {launching jobs}{456}{launching jobs}
\entry {process group leader}{456}{process group leader}
\entry {process group ID}{456}{process group ID}
\entry {race conditions, relating to job control}{456}{race conditions, relating to job control}
\entry {foreground job, launching}{460}{foreground job, launching}
\entry {background job, launching}{461}{background job, launching}
\entry {stopped jobs, detecting}{461}{stopped jobs, detecting}
\entry {terminated jobs, detecting}{461}{terminated jobs, detecting}
\entry {SIGCHLD, handling of}{461}{\code {SIGCHLD}, handling of}
\entry {stopped jobs, continuing}{466}{stopped jobs, continuing}
\entry {process group functions}{467}{process group functions}
\entry {job control functions}{467}{job control functions}
\entry {controlling terminal, determining}{467}{controlling terminal, determining}
\entry {BSD compatibility library}{469}{BSD compatibility library}
\entry {login name}{473}{login name}
\entry {user name}{473}{user name}
\entry {user ID}{473}{user ID}
\entry {group name}{473}{group name}
\entry {group ID}{473}{group ID}
\entry {persona}{473}{persona}
\entry {effective user ID}{473}{effective user ID}
\entry {effective group ID}{473}{effective group ID}
\entry {real user ID}{474}{real user ID}
\entry {real group ID}{474}{real group ID}
\entry {supplementary group IDs}{474}{supplementary group IDs}
\entry {setuid programs}{475}{\code {setuid} programs}
\entry {login name, determining}{483}{login name, determining}
\entry {user ID, determining}{483}{user ID, determining}
\entry {user database}{484}{user database}
\entry {password database}{484}{password database}
\entry {converting user ID to user name}{484}{converting user ID to user name}
\entry {converting user name to user ID}{484}{converting user name to user ID}
\entry {scanning the user list}{485}{scanning the user list}
\entry {group database}{486}{group database}
\entry {converting group name to group ID}{487}{converting group name to group ID}
\entry {converting group ID to group name}{487}{converting group ID to group name}
\entry {scanning the group list}{487}{scanning the group list}
\entry {POSIX capacity limits}{495}{POSIX capacity limits}
\entry {limits, POSIX}{495}{limits, POSIX}
\entry {capacity limits, POSIX}{495}{capacity limits, POSIX}
\entry {limits, program argument size}{495}{limits, program argument size}
\entry {limits, number of processes}{495}{limits, number of processes}
\entry {limits, number of open files}{495}{limits, number of open files}
\entry {limits, time zone name length}{495}{limits, time zone name length}
\entry {limits, number of supplementary group IDs}{496}{limits, number of supplementary group IDs}
\entry {POSIX optional features}{496}{POSIX optional features}
\entry {optional POSIX features}{496}{optional POSIX features}
\entry {limits, link count of files}{503}{limits, link count of files}
\entry {limits, terminal input queue}{503}{limits, terminal input queue}
\entry {limits, file name length}{503}{limits, file name length}
\entry {limits, pipe buffer size}{504}{limits, pipe buffer size}
\entry {consistency checking}{511}{consistency checking}
\entry {impossible events}{511}{impossible events}
\entry {assertions}{511}{assertions}
\entry {variable number of arguments}{512}{variable number of arguments}
\entry {variadic functions}{512}{variadic functions}
\entry {optional arguments}{512}{optional arguments}
\entry {function prototypes (variadic)}{513}{function prototypes (variadic)}
\entry {prototypes for variadic functions}{513}{prototypes for variadic functions}
\entry {variadic function prototypes}{513}{variadic function prototypes}
\entry {variadic function argument access}{514}{variadic function argument access}
\entry {arguments (variadic functions)}{514}{arguments (variadic functions)}
\entry {number of arguments passed}{515}{number of arguments passed}
\entry {how many arguments}{515}{how many arguments}
\entry {arguments, how many}{515}{arguments, how many}
\entry {variadic functions, calling}{515}{variadic functions, calling}
\entry {calling variadic functions}{515}{calling variadic functions}
\entry {declaring variadic functions}{515}{declaring variadic functions}
\entry {default argument promotions}{516}{default argument promotions}
\entry {argument promotion}{516}{argument promotion}
\entry {null pointer constant}{519}{null pointer constant}
\entry {integer type width}{520}{integer type width}
\entry {width of integer type}{520}{width of integer type}
\entry {type measurements, integer}{520}{type measurements, integer}
\entry {integer type range}{521}{integer type range}
\entry {range of integer type}{521}{range of integer type}
\entry {limits, integer types}{521}{limits, integer types}
\entry {floating type measurements}{522}{floating type measurements}
\entry {measurements of floating types}{522}{measurements of floating types}
\entry {type measurements, floating}{522}{type measurements, floating}
\entry {limits, floating types}{522}{limits, floating types}
\entry {sign (of floating point number)}{523}{sign (of floating point number)}
\entry {base (of floating point number)}{523}{base (of floating point number)}
\entry {radix (of floating point number)}{523}{radix (of floating point number)}
\entry {exponent (of floating point number)}{523}{exponent (of floating point number)}
\entry {bias (of floating point number exponent)}{523}{bias (of floating point number exponent)}
\entry {mantissa (of floating point number)}{523}{mantissa (of floating point number)}
\entry {significand (of floating point number)}{523}{significand (of floating point number)}
\entry {precision (of floating point number)}{523}{precision (of floating point number)}
\entry {hidden bit (of floating point number mantissa)}{523}{hidden bit (of floating point number mantissa)}
\entry {normalized floating point number}{524}{normalized floating point number}
\entry {IEEE floating point representation}{527}{IEEE floating point representation}
\entry {floating point, IEEE}{527}{floating point, IEEE}
\entry {installing the library}{609}{installing the library}
\entry {reporting bugs}{612}{reporting bugs}